{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "74a30495",
   "metadata": {},
   "source": [
    "🏡 我的环境：\n",
    "\n",
    "+ 语言环境：Python3.8\n",
    "+ 编译器：jupyter notebook\n",
    "+ 深度学习环境：Pytorch"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23ea5058",
   "metadata": {},
   "source": [
    "# 一、 前期准备\n",
    "\n",
    "## 1. 设置GPU\n",
    "\n",
    "如果设备上支持GPU就使用GPU,否则使用CPU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92238a52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda')"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e2b0ce2",
   "metadata": {},
   "source": [
    "## 2. 导入数据\n",
    "\n",
    "使用dataset下载MNIST数据集，并划分好训练集与测试集\n",
    "\n",
    "使用dataloader加载数据，并设置好基本的batch_size"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ed744c1-3010-4d51-8980-fafd710c4b09",
   "metadata": {},
   "source": [
    "⭐ **`torchvision.datasets.MNIST详解`** \n",
    "\n",
    "`torchvision.datasets`是Pytorch自带的一个数据库，我们可以通过代码在线下载数据，这里使用的是`torchvision.datasets`中的`MNIST`数据集。\n",
    "\n",
    "**函数原型：**\n",
    "```python\n",
    "torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)\n",
    "```\n",
    "**参数说明：**\n",
    "- **root** (string) ：数据地址\n",
    "- **train** (string) ：`True` = 训练集，`False` = 测试集 \n",
    "- **download** (bool,optional) : 如果为`True`，从互联网上下载数据集，并把数据集放在root目录下。\n",
    "- **transform** (callable, optional )：这里的参数选择一个你想要的数据转化函数，直接完成数据转化\n",
    "- **target_transform** (callable,optional) ：接受目标并对其进行转换的函数/转换。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "14e56ce1",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_ds = torchvision.datasets.MNIST('data', \n",
    "                                      train=True, \n",
    "                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor\n",
    "                                      download=True)\n",
    "\n",
    "test_ds  = torchvision.datasets.MNIST('data', \n",
    "                                      train=False, \n",
    "                                      transform=torchvision.transforms.ToTensor(), # 将数据类型转化为Tensor\n",
    "                                      download=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bbc8233-d284-4815-b96c-1af5ad655f93",
   "metadata": {},
   "source": [
    "📌请在这里补充关于`torch.utils.data.DataLoader`的介绍（建议参照`torchvision.datasets.MNIST`详解）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "48d40c87",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "\n",
    "train_dl = torch.utils.data.DataLoader(train_ds, \n",
    "                                       batch_size=batch_size, \n",
    "                                       shuffle=True)\n",
    "\n",
    "test_dl  = torch.utils.data.DataLoader(test_ds, \n",
    "                                       batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "75655f1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([32, 1, 28, 28])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 取一个批次查看数据格式\n",
    "# 数据的shape为：[batch_size, channel, height, weight]\n",
    "# 其中batch_size为自己设定，channel，height和weight分别是图片的通道数，高度和宽度。\n",
    "imgs, labels = next(iter(train_dl))\n",
    "imgs.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "102647e8",
   "metadata": {},
   "source": [
    "## 3. 数据可视化"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07f802e5-8a53-4fa4-b1ca-21131231a27f",
   "metadata": {},
   "source": [
    "`squeeze()`函数的功能是从矩阵shape中，去掉维度为1的。例如一个矩阵是的shape是（5, 1），使用过这个函数后，结果为（5, ）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "e235b34c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1440x360 with 20 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    " # 指定图片大小，图像大小为20宽、5高的绘图(单位为英寸inch)\n",
    "plt.figure(figsize=(20, 5)) \n",
    "for i, imgs in enumerate(imgs[:20]):\n",
    "    # 维度缩减\n",
    "    npimg = np.squeeze(imgs.numpy())\n",
    "    # 将整个figure分成2行10列，绘制第i+1个子图。\n",
    "    plt.subplot(2, 10, i+1)\n",
    "    plt.imshow(npimg, cmap=plt.cm.binary)\n",
    "    plt.axis('off')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebf2dcc1",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 二、构建简单的CNN网络\n",
    "\n",
    " 对于一般的CNN网络来说，都是由特征提取网络和分类网络构成，其中特征提取网络用于提取图片的特征，分类网络用于将图片进行分类。\n",
    "\n",
    "nn.Conv2d为[卷积层](https://pytorch.org/docs/stable/generated/torch.nn.Conv2d.html#torch.nn.Conv2d)，用于提取图片的特征，传入参数为输入channel，输出channel，池化核大小\n",
    "\n",
    "nn.MaxPool2d为[池化层](https://pytorch.org/docs/stable/generated/torch.nn.MaxPool2d.html#torch.nn.MaxPool2d)，进行下采样，用更高层的抽象表示图像特征，传入参数为池化核大小\n",
    "\n",
    "nn.ReLU为[激活函数](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html?highlight=relu#torch.nn.ReLU)，使模型可以拟合非线性数据\n",
    "\n",
    "nn.Linear为[全连接层](https://pytorch.org/docs/stable/generated/torch.nn.Linear.html#torch.nn.Linear)，可以起到特征提取器的作用，最后一层的全连接层也可以认为是输出层，传入参数为输入特征数和输出特征数（输入特征数由特征提取网络计算得到，如果不会计算可以直接运行网络，报错中会提示输入特征数的大小，下方网络中第一个全连接层的输入特征数为1600）\n",
    "\n",
    "nn.Sequential可以[按构造顺序连接网络](https://pytorch.org/docs/stable/generated/torch.nn.Sequential.html?highlight=sequential#torch.nn.Sequential)，在初始化阶段就设定好网络结构，不需要在前向传播中重新写一遍"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eb2e11bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn.functional as F\n",
    "\n",
    "num_classes = 10  # 图片的类别数\n",
    "\n",
    "class Model(nn.Module):\n",
    "     def __init__(self):\n",
    "        super().__init__()\n",
    "         # 特征提取网络\n",
    "        self.conv1 = nn.Conv2d(1, 32, kernel_size=3)  # 第一层卷积,卷积核大小为3*3\n",
    "        self.pool1 = nn.MaxPool2d(2)                  # 设置池化层，池化核大小为2*2\n",
    "        self.conv2 = nn.Conv2d(32, 64, kernel_size=3) # 第二层卷积,卷积核大小为3*3   \n",
    "        self.pool2 = nn.MaxPool2d(2) \n",
    "                                      \n",
    "        # 分类网络\n",
    "        self.fc1 = nn.Linear(1600, 64)          \n",
    "        self.fc2 = nn.Linear(64, num_classes)\n",
    "     # 前向传播\n",
    "     def forward(self, x):\n",
    "        x = self.pool1(F.relu(self.conv1(x)))     \n",
    "        x = self.pool2(F.relu(self.conv2(x)))\n",
    "\n",
    "        x = torch.flatten(x, start_dim=1)\n",
    "\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = self.fc2(x)\n",
    "       \n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c369d8bc",
   "metadata": {},
   "source": [
    "加载并打印模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "ccde1c16",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "=================================================================\n",
       "Layer (type:depth-idx)                   Param #\n",
       "=================================================================\n",
       "Model                                    --\n",
       "├─Conv2d: 1-1                            320\n",
       "├─MaxPool2d: 1-2                         --\n",
       "├─Conv2d: 1-3                            18,496\n",
       "├─MaxPool2d: 1-4                         --\n",
       "├─Linear: 1-5                            102,464\n",
       "├─Linear: 1-6                            650\n",
       "=================================================================\n",
       "Total params: 121,930\n",
       "Trainable params: 121,930\n",
       "Non-trainable params: 0\n",
       "================================================================="
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from torchinfo import summary\n",
    "# 将模型转移到GPU中（我们模型运行均在GPU中进行）\n",
    "model = Model().to(device)\n",
    "\n",
    "summary(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fed53298",
   "metadata": {},
   "source": [
    "# 三、 训练模型\n",
    "\n",
    "## 1. 设置超参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "bdbe0414",
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn    = nn.CrossEntropyLoss() # 创建损失函数\n",
    "learn_rate = 1e-2 # 学习率\n",
    "opt        = torch.optim.SGD(model.parameters(),lr=learn_rate)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76dd0725",
   "metadata": {},
   "source": [
    "## 2. 编写训练函数\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c02c0252-ea36-4a1a-8bd8-ce5f13d81081",
   "metadata": {},
   "source": [
    "**1. optimizer.zero_grad()**\n",
    "\n",
    "函数会遍历模型的所有参数，通过内置方法截断反向传播的梯度流，再将每个参数的梯度值设为0，即上一次的梯度记录被清空。\n",
    "\n",
    "**2. loss.backward()**\n",
    "\n",
    "PyTorch的反向传播(即`tensor.backward()`)是通过autograd包来实现的，autograd包会根据tensor进行过的数学运算来自动计算其对应的梯度。\n",
    "\n",
    "具体来说，torch.tensor是autograd包的基础类，如果你设置tensor的requires_grads为True，就会开始跟踪这个tensor上面的所有运算，如果你做完运算后使用`tensor.backward()`，所有的梯度就会自动运算，tensor的梯度将会累加到它的.grad属性里面去。\n",
    "\n",
    "更具体地说，损失函数loss是由模型的所有权重w经过一系列运算得到的，若某个w的requires_grads为True，则w的所有上层参数（后面层的权重w）的.grad_fn属性中就保存了对应的运算，然后在使用`loss.backward()`后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。\n",
    "\n",
    "如果没有进行`tensor.backward()`的话，梯度值将会是None，因此`loss.backward()`要写在`optimizer.step()`之前。\n",
    "\n",
    "**3. optimizer.step()**\n",
    "\n",
    "step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行`optimizer.step()`函数前应先执行`loss.backward()`函数来计算梯度。\n",
    "\n",
    "注意：optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是`tensor.backward()`方法产生的。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "029e0d26",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 训练循环\n",
    "def train(dataloader, model, loss_fn, optimizer):\n",
    "    size = len(dataloader.dataset)  # 训练集的大小，一共60000张图片\n",
    "    num_batches = len(dataloader)   # 批次数目，1875（60000/32）\n",
    "\n",
    "    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率\n",
    "    \n",
    "    for X, y in dataloader:  # 获取图片及其标签\n",
    "        X, y = X.to(device), y.to(device)\n",
    "        \n",
    "        # 计算预测误差\n",
    "        pred = model(X)          # 网络输出\n",
    "        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距，targets为真实值，计算二者差值即为损失\n",
    "        \n",
    "        # 反向传播\n",
    "        optimizer.zero_grad()  # grad属性归零\n",
    "        loss.backward()        # 反向传播\n",
    "        optimizer.step()       # 每一步自动更新\n",
    "        \n",
    "        # 记录acc与loss\n",
    "        train_acc  += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
    "        train_loss += loss.item()\n",
    "            \n",
    "    train_acc  /= size\n",
    "    train_loss /= num_batches\n",
    "\n",
    "    return train_acc, train_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4c23614",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 3. 编写测试函数\n",
    "\n",
    "测试函数和训练函数大致相同，但是由于不进行梯度下降对网络权重进行更新，所以不需要传入优化器"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "428d2bc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(dataloader, model, loss_fn):\n",
    "    size        = len(dataloader.dataset)  # 测试集的大小，一共10000张图片\n",
    "    num_batches = len(dataloader)          # 批次数目，313（10000/32=312.5，向上取整）\n",
    "    \n",
    "    test_loss, test_acc = 0, 0\n",
    "    \n",
    "    # 当不进行训练时，停止梯度更新，节省计算内存消耗\n",
    "    with torch.no_grad():\n",
    "        for imgs, target in dataloader:\n",
    "            imgs, target = imgs.to(device), target.to(device)\n",
    "            \n",
    "            # 计算loss\n",
    "            target_pred = model(imgs)\n",
    "            loss        = loss_fn(target_pred, target)\n",
    "            \n",
    "            test_loss += loss.item()\n",
    "            test_acc  += (target_pred.argmax(1) == target).type(torch.float).sum().item()\n",
    "\n",
    "    test_acc  /= size\n",
    "    test_loss /= num_batches\n",
    "\n",
    "    return test_acc, test_loss"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83ad510f",
   "metadata": {
    "tags": []
   },
   "source": [
    "## 4. 正式训练\n",
    "\n",
    "**1. model.train()**\n",
    "\n",
    "`model.train()`的作用是启用 Batch Normalization 和 Dropout。\n",
    "\n",
    "如果模型中有`BN`层(Batch Normalization）和`Dropout`，需要在训练时添加`model.train()`。`model.train()`是保证BN层能够用到每一批数据的均值和方差。对于`Dropout`，`model.train()`是随机取一部分网络连接来训练更新参数。\n",
    "\n",
    "**2. model.eval()**\n",
    "\n",
    "`model.eval()`的作用是不启用 Batch Normalization 和 Dropout。\n",
    "\n",
    "如果模型中有BN层(Batch Normalization）和Dropout，在测试时添加`model.eval()`。`model.eval()`是保证BN层能够用全部训练数据的均值和方差，即测试过程中要保证BN层的均值和方差不变。对于`Dropout`，`model.eval()`是利用到了所有网络连接，即不进行随机舍弃神经元。\n",
    "\n",
    "训练完train样本后，生成的模型model要用来测试样本。在`model(test)`之前，需要加上`model.eval()`，否则的话，有输入数据，即使不训练，它也会改变权值。这是model中含有BN层和Dropout所带来的的性质。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "db53b0cc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1, Train_acc:81.2%, Train_loss:0.651, Test_acc:93.6%，Test_loss:0.219\n",
      "Epoch: 2, Train_acc:94.6%, Train_loss:0.182, Test_acc:96.1%，Test_loss:0.130\n",
      "Epoch: 3, Train_acc:96.5%, Train_loss:0.117, Test_acc:97.3%，Test_loss:0.092\n",
      "Epoch: 4, Train_acc:97.2%, Train_loss:0.091, Test_acc:97.8%，Test_loss:0.070\n",
      "Epoch: 5, Train_acc:97.7%, Train_loss:0.076, Test_acc:98.3%，Test_loss:0.058\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "epochs     = 5\n",
    "train_loss = []\n",
    "train_acc  = []\n",
    "test_loss  = []\n",
    "test_acc   = []\n",
    "\n",
    "for epoch in range(epochs):\n",
    "    model.train()\n",
    "    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)\n",
    "    \n",
    "    model.eval()\n",
    "    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)\n",
    "    \n",
    "    train_acc.append(epoch_train_acc)\n",
    "    train_loss.append(epoch_train_loss)\n",
    "    test_acc.append(epoch_test_acc)\n",
    "    test_loss.append(epoch_test_loss)\n",
    "    \n",
    "    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%，Test_loss:{:.3f}')\n",
    "    print(template.format(epoch+1, epoch_train_acc*100, epoch_train_loss, epoch_test_acc*100, epoch_test_loss))\n",
    "print('Done')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "323977a2",
   "metadata": {
    "tags": []
   },
   "source": [
    "# 四、 结果可视化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "9aac9674-c9c5-4eee-8a9b-54b7a63400ca",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1200x300 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "#隐藏警告\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")               #忽略警告信息\n",
    "plt.rcParams['font.sans-serif']    = ['SimHei'] # 用来正常显示中文标签\n",
    "plt.rcParams['axes.unicode_minus'] = False      # 用来正常显示负号\n",
    "plt.rcParams['figure.dpi']         = 100        #分辨率\n",
    "\n",
    "epochs_range = range(epochs)\n",
    "\n",
    "plt.figure(figsize=(12, 3))\n",
    "plt.subplot(1, 2, 1)\n",
    "\n",
    "plt.plot(epochs_range, train_acc, label='Training Accuracy')\n",
    "plt.plot(epochs_range, test_acc, label='Test Accuracy')\n",
    "plt.legend(loc='lower right')\n",
    "plt.title('Training and Validation Accuracy')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(epochs_range, train_loss, label='Training Loss')\n",
    "plt.plot(epochs_range, test_loss, label='Test Loss')\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Training and Validation Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c64ceae9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
